home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / 031-040 / amok32 / modlist1.3 / m2p.mod < prev    next >
Text File  |  1993-11-04  |  16KB  |  595 lines
  1. (*******************************************************************************
  2.  
  3.     :Program.    Originalname        : ModList.mod
  4.     :Program.    Vorschlag (A.Lüdtke)    : M2P.mod
  5.     :Contents.   Ausdrucken von Modula-Sources mit Hervorhebung der
  6.     :Contents.   Modula-Schlüsselwörter und Kommentare
  7.     :Author.     Ursprüngliche PC-Version: CHIP/Tool-Praxis Modula-2/Sonderheft
  8.     :Author.     Amiga-Version: Andreas Kopp
  9.     :Author.     Anpassung an Amiga-Druckertreiber : Nicolas Benezan [bne]
  10.     :Address.    Andreas Kopp, Grünbaumstrasse 83  D-5650 Solingen 1
  11.     :Phone.      (0)212 / 42381
  12.     :Copyright.  Public Domain
  13.     :Language.   Modula-2
  14.     :Translator. M2Amiga A+L V3.2d
  15.     :History.    V1.0 A. Kopp   25.Mar.1989 (Amiga Version)
  16.     :History.    V1.1 [bne]     29.Mar.1989 (Druckeranpassung, SingleSheet)
  17.     :History.    V1.2b [bne]     2.Apr.1989 (Ctrl-C Bug fixed);
  18.     :History.    V1.3 A.Lüdtke  10.Dez.1989
  19.     :History.    Tabs durch 1..8*Space ersetzt, FF am Ende des Textes, bei FF
  20.     :History.    im Text neue Seite beginnen, Steuerzeichen durch ^Buchstabe
  21.     :History.    fett darstellen, Dateiname, Datum und Zeit auf jeder Seite
  22.     :History.    anzeigen, auf Preferences (Paperlength und Spacing)
  23.     :History.    reagieren.
  24.  
  25. *******************************************************************************)
  26.  
  27. MODULE M2P;
  28.  
  29. FROM Dos        IMPORT Date, DateStamp;
  30. FROM Str        IMPORT Length, Concat;
  31. FROM Arts        IMPORT Requester, Terminate, wbStarted;
  32. FROM Heap        IMPORT Allocate, Deallocate;
  33. FROM ASCII        IMPORT eol, cr, lf, esc, ht, ff, nul, bs, vt, so, us;
  34. FROM SYSTEM        IMPORT ADR, ADDRESS, FFP;
  35. FROM Terminal        IMPORT WriteLn, WriteString, ReadLn, waitCloseGadget;
  36. FROM Arguments        IMPORT GetArg, NumArgs;
  37. FROM Intuition        IMPORT GetPrefs, Preferences, PreferencesPtr, single,
  38.     draft, letter, pica, elite, fine, sixLPI, eightLPI;
  39. FROM FileSystem        IMPORT File, Response, ReadChar, WriteChar, WriteBytes,
  40.     WriteByteBlock, Lookup, Close;
  41. FROM Conversions    IMPORT ValToStr;
  42.  
  43.  
  44. CONST
  45.   MaxZeichen        = 255;
  46.   BoldOn        = "[1m";    BoldOnLen        = 3;
  47.   BoldOff        = "[22m";    BoldOffLen        = 4;
  48.   ItalOn        = "[3m";    ItalOnLen        = 3;
  49.   ItalOff        = "[23m";    ItalOffLen        = 4;
  50.  
  51. VAR
  52.   Puffer        : ARRAY [0..MaxZeichen] OF CHAR;
  53.   Zeichen        : CHAR;
  54.   Zustand        : (ZeichenLesen, WortLesen, String1, String2,
  55.                Kommentar, FileEnde);
  56.   ZeilenNr        : CARDINAL;
  57.   SeitenNr        : CARDINAL;
  58.   ZeichenZahl        : CARDINAL;
  59.   KommentarTiefe    : CARDINAL;
  60.   SingleSheet        : BOOLEAN;
  61.   InFile        : File;
  62.   OutFile        : File;
  63.   InputName        : ARRAY [0..31] OF CHAR;
  64.   OutputName        : ARRAY [0..31] OF CHAR;
  65.   Len            : INTEGER;
  66.   Dummy            : LONGINT;
  67.   count            : CARDINAL;
  68.   CharCount        : CARDINAL;
  69.   DatString        : ARRAY [0..40] OF CHAR;
  70.   ZeilenProSeite    : CARDINAL;
  71.   ZeichenProZeile    : CARDINAL;
  72.  
  73.  
  74. (* --- Preferences auslesen und gesetzte Parameter feststellen --- *)
  75.  
  76. PROCEDURE ReadPrefs;
  77. VAR
  78.   Prefs:PreferencesPtr;
  79. BEGIN
  80.   Allocate(Prefs,SIZE(Preferences));
  81.   GetPrefs(Prefs,SIZE(Preferences));
  82.   WITH Prefs^ DO
  83.     SingleSheet        := paperType = single;
  84.     ZeilenProSeite    := paperLength;
  85.     IF printSpacing = eightLPI THEN
  86.       ZeilenProSeite := CARDINAL( 1.33 * (FFP(ZeilenProSeite) + 0.5));
  87.     END;
  88.     ZeichenProZeile    := printRightMargin - printLeftMargin;
  89.     IF printRightMargin <= printLeftMargin THEN
  90.       ZeichenProZeile := 10;
  91.     END;
  92.     IF (printRightMargin - printLeftMargin) > MaxZeichen THEN
  93.       ZeichenProZeile := MaxZeichen;
  94.     END;
  95.   END;
  96.   Deallocate(Prefs);
  97. END ReadPrefs;
  98.  
  99. (* --------- Lokales Modul zur gepufferten Eingabe eines Zeichens ---------- *)
  100.  
  101. MODULE GepuffertesLesen;
  102.  
  103. IMPORT ReadChar, InFile, FileEnde, Zustand;
  104. EXPORT Read, PushBack;
  105.  
  106. VAR ZeichenPuffer : CHAR;
  107.  
  108. PROCEDURE Read ( VAR Zeichen : CHAR);
  109. BEGIN
  110.   IF ZeichenPuffer=0C THEN
  111.     ReadChar(InFile,Zeichen);
  112.     IF InFile.eof THEN
  113.       Zustand := FileEnde;
  114.     END;
  115.   ELSE
  116.     Zeichen := ZeichenPuffer;
  117.     ZeichenPuffer := 0C;
  118.   END;
  119. END Read;
  120.  
  121. PROCEDURE PushBack(Zeichen : CHAR);
  122. BEGIN
  123.   ZeichenPuffer := Zeichen;
  124. END PushBack;
  125.  
  126. BEGIN (* Initialisierung *)
  127.   ZeichenPuffer := 0C;
  128. END GepuffertesLesen;
  129.  
  130. (* ----- Lokales Modul zur Bestimmung, ob es sich bei einem Bezeichner ----- *)
  131. (* ----- um ein Schluesselwort handelt -------------------------------------- *)
  132.  
  133. MODULE ReservierteWoerter;
  134.  
  135. EXPORT ReserviertesWort;
  136.  
  137. VAR
  138.   ResWort : ARRAY [1..40] OF ARRAY [0..15] OF CHAR;
  139.  
  140. PROCEDURE ReserviertesWort(Bezeichner : ARRAY OF CHAR) : BOOLEAN;
  141. VAR
  142.   von, bis, mitte : [1..40];
  143.  
  144. PROCEDURE kleiner(X,Y : ARRAY OF CHAR) : BOOLEAN;
  145. VAR
  146.   i, Minimum : CARDINAL;
  147. BEGIN
  148.   IF HIGH(X) < HIGH(Y) THEN
  149.     Minimum := HIGH(X)
  150.   ELSE
  151.     Minimum := HIGH(Y)
  152.   END;
  153.   i := 0;
  154.   WHILE (i < Minimum) AND (X[i] = Y[i]) AND (X[i] # 0C) AND (Y[i] # 0C) DO
  155.     INC(i);
  156.   END;
  157.   RETURN X[i] < Y[i];
  158. END kleiner;
  159.  
  160. BEGIN
  161.   von := 1; bis := 40;
  162.   WHILE von # bis DO
  163.     mitte := (von+bis) DIV 2;
  164.     IF kleiner(ResWort[mitte],Bezeichner) THEN
  165.       von := mitte+1;
  166.     ELSE
  167.       bis := mitte
  168.     END;
  169.   END;
  170.   RETURN NOT kleiner(ResWort[von], Bezeichner) AND
  171.          NOT kleiner(Bezeichner,ResWort[von]);
  172. END ReserviertesWort;
  173.  
  174. BEGIN
  175.   ResWort[ 1]:="AND";           ResWort[21]:="LOOP";
  176.   ResWort[ 2]:="ARRAY";         ResWort[22]:="MOD";
  177.   ResWort[ 3]:="BEGIN";         ResWort[23]:="MODULE";
  178.   ResWort[ 4]:="BY";            ResWort[24]:="NOT";
  179.   ResWort[ 5]:="CASE";          ResWort[25]:="OF";
  180.   ResWort[ 6]:="CONST";         ResWort[26]:="OR";
  181.   ResWort[ 7]:="DEFINITION";    ResWort[27]:="POINTER";
  182.   ResWort[ 8]:="DIV";           ResWort[28]:="PROCEDURE";
  183.   ResWort[ 9]:="DO";            ResWort[29]:="QUALIFIED";
  184.   ResWort[10]:="ELSE";          ResWort[30]:="RECORD";
  185.   ResWort[11]:="ELSIF";         ResWort[31]:="REPEAT";
  186.   ResWort[12]:="END";           ResWort[32]:="RETURN";
  187.   ResWort[13]:="EXIT";          ResWort[33]:="SET";
  188.   ResWort[14]:="EXPORT";        ResWort[34]:="THEN";
  189.   ResWort[15]:="FOR";           ResWort[35]:="TO";
  190.   ResWort[16]:="FROM";          ResWort[36]:="TYPE";
  191.   ResWort[17]:="IF";            ResWort[37]:="UNTIL";
  192.   ResWort[18]:="IMPLEMENTATION";ResWort[38]:="VAR";
  193.   ResWort[19]:="IMPORT";        ResWort[39]:="WHILE";
  194.   ResWort[20]:="IN";            ResWort[40]:="WITH";
  195. END ReservierteWoerter;
  196.  
  197.  
  198. PROCEDURE WriteEscStr(adresse : ADDRESS; len : LONGINT);
  199. VAR
  200.   geschrieben    : LONGINT;
  201. BEGIN
  202.   WriteChar(OutFile,esc);
  203.   WriteBytes(OutFile,adresse,len,geschrieben);
  204. END WriteEscStr;
  205.  
  206.  
  207. PROCEDURE Write(Char: CHAR);
  208. BEGIN
  209.   WriteChar(OutFile,Char);
  210. END Write;
  211.  
  212.  
  213. PROCEDURE WriteCtrl(Char: CHAR);
  214. BEGIN
  215.   WriteEscStr(ADR(BoldOn),BoldOnLen);    (* Fettdruck anschalten        *)
  216.   WriteChar(OutFile,"^");
  217.   WriteChar(OutFile, CHAR( ORD(Zeichen) + 64));
  218.   WriteEscStr(ADR(BoldOff),BoldOffLen);    (* Fettdruck ausschalten    *)
  219.   INC(CharCount,2);
  220. END WriteCtrl;
  221.  
  222.  
  223. (* --- Steuerzeichen (Escape-Sequenzen) nach ISO-Norm               --- *)
  224. (* --- werden vom PRT:-Device automatisch für den Drucker übersetzt --- *)
  225.  
  226. PROCEDURE InitDrucker;
  227. BEGIN
  228.   Write(esc); Write("c");        (* ISO Reset Kommando        *)
  229.   Write(esc); Write("#"); Write("1");    (* ISO Initialisierung        *)
  230. END InitDrucker;
  231.  
  232.  
  233. PROCEDURE FettAn;
  234. BEGIN
  235.   WriteEscStr(ADR(BoldOn),BoldOnLen);
  236. END FettAn;
  237.  
  238.  
  239. PROCEDURE FettAus;
  240. BEGIN
  241.   WriteEscStr(ADR(BoldOff),BoldOffLen);
  242. END FettAus;
  243.  
  244.  
  245. PROCEDURE MarkiereWort(Bezeichner: ARRAY OF CHAR;Len: LONGINT);
  246. BEGIN
  247.   FettAn;
  248.   WriteBytes(OutFile,ADR(Bezeichner),Len,Len);
  249.   FettAus;
  250. END MarkiereWort;
  251.  
  252.  
  253. PROCEDURE KursivAn;
  254. BEGIN
  255.   WriteEscStr(ADR(ItalOn),ItalOnLen);    (* italics on    *)
  256. END KursivAn;
  257.  
  258.  
  259. PROCEDURE KursivAus;
  260. BEGIN
  261.   WriteEscStr(ADR(ItalOff),ItalOffLen);    (* italics off    *)
  262. END KursivAus;
  263.  
  264.  
  265. (* ------------------- Seitenumbruch und Zeilennummern --------------------- *)
  266.  
  267. PROCEDURE WriteCard(Val,Digits:CARDINAL);
  268. VAR
  269.   Error        : BOOLEAN;
  270.   Str        : ARRAY [0..7] OF CHAR;
  271. BEGIN
  272.   ValToStr(Val,FALSE,Str,10,Digits," ",Error);
  273.   IF NOT Error THEN
  274.     WriteBytes(OutFile,ADR(Str),Length(Str),Dummy);
  275.   END;
  276. END WriteCard;
  277.  
  278.  
  279. PROCEDURE NeueSeite;
  280. VAR
  281.   act    : LONGINT;
  282. BEGIN
  283.   IF ZeilenNr>0 THEN
  284.     Write(CHR(12));
  285.     IF SingleSheet THEN
  286.       IF NOT Requester(ADR("M2P (Modula-2 Print)"),
  287.                ADR("Bitte nächstes Blatt einlegen"),
  288.                ADR("weiter"),
  289.                ADR("abbrechen")) THEN
  290.     Terminate(0);
  291.       END;
  292.     END;
  293.   END;
  294.   INC(SeitenNr);
  295.   KursivAn; FettAn;
  296.   WriteByteBlock(OutFile,"Seite ");
  297.   WriteCard(SeitenNr,2);
  298.   WriteByteBlock(OutFile,"    ");
  299.   WriteBytes(OutFile,ADR(InputName),LONGINT(Length(InputName)),act);
  300.   WriteByteBlock(OutFile,"     ");
  301.   WriteBytes(OutFile,ADR(DatString),LONGINT(Length(DatString)),act);
  302.   FettAus; KursivAus;
  303.   Write(cr); Write(lf); Write(lf);
  304. END NeueSeite;
  305.  
  306.  
  307. PROCEDURE NeueZeile;
  308. VAR
  309.   test : CARDINAL;
  310. BEGIN
  311.   Read(Zeichen);
  312.   IF Zeichen # cr THEN
  313.     PushBack(Zeichen);
  314.   END;
  315.   IF ZeilenNr MOD ZeilenProSeite = 0 THEN
  316.     NeueSeite;
  317.   ELSE
  318.     Write(cr); Write(lf);
  319.   END;
  320.   INC(ZeilenNr);
  321.   KursivAn;
  322.   WriteCard(ZeilenNr,4);
  323.   Write(":"); Write(" ");
  324.   IF KommentarTiefe = 0 THEN
  325.     KursivAus;
  326.   END;
  327. END NeueZeile;
  328.  
  329.  
  330. PROCEDURE Schaltjahr( Jahr : LONGINT ) : LONGINT;
  331. VAR
  332.   dummy    : LONGINT;
  333. BEGIN
  334.   dummy := 0;
  335.   IF (Jahr REM 4)   = 0 THEN dummy := 1 END;
  336.   IF (Jahr REM 100) = 0 THEN dummy := 0 END;
  337.   IF (Jahr REM 400) = 0 THEN dummy := 1 END;
  338.   RETURN( dummy);
  339. END Schaltjahr;
  340.  
  341.  
  342. PROCEDURE TageProMonat( Monat : LONGINT;
  343.              Jahr : LONGINT) : LONGINT;
  344. VAR
  345.   dummy : LONGINT;
  346. BEGIN
  347.   CASE Monat OF
  348.     1,3,5,7,8,10,12 : dummy := 31            |
  349.     2               : dummy := 28 + Schaltjahr( Jahr)    |
  350.     4,6,9,11        : dummy := 30
  351.   END;
  352.   RETURN( dummy);
  353. END TageProMonat;
  354.  
  355.  
  356. PROCEDURE ConvertDate;
  357. VAR
  358.   Tage    : LONGINT;
  359.   Monat    : LONGINT;
  360.   Jahr    : LONGINT;
  361.   HStr    : ARRAY[1..10] OF CHAR;
  362.   Error    : BOOLEAN;
  363.   Datum    : Date;
  364. BEGIN
  365.   DateStamp(ADR(Datum));
  366.   Tage := Datum.days + 1;    (* plus 1 da 'Tage seit 1.1.78'        *)
  367.   Jahr := 1978;
  368.   WHILE Tage > 366 DO
  369.     DEC( Tage, 365 + Schaltjahr( Jahr));
  370.     INC( Jahr);
  371.   END;
  372.   Monat := 1;
  373.   WHILE Tage > 31 DO
  374.     DEC( Tage, TageProMonat( Monat, Jahr));
  375.     INC( Monat);
  376.   END;
  377.   CASE (Datum.days REM 7) OF
  378.     0: DatString := "Sonntag "        |
  379.     1: DatString := "Montag "        |
  380.     2: DatString := "Dienstag "        |
  381.     3: DatString := "Mittwoch "        |
  382.     4: DatString := "Donnerstag "    |
  383.     5: DatString := "Freitag "        |
  384.     6: DatString := "Samstag "
  385.   END;
  386.   ValToStr( Tage, FALSE, HStr, 10, 2, " ", Error);
  387.   Concat( DatString, HStr); Concat( DatString, ".");
  388.   CASE Monat OF
  389.     1:  HStr := "Januar "    |
  390.     2:  HStr := "Februar "    |
  391.     3:  HStr := "März "        |
  392.     4:  HStr := "April "    |
  393.     5:  HStr := "Mai "        |
  394.     6:  HStr := "Juni "        |
  395.     7:  HStr := "Juli "        |
  396.     8:  HStr := "August "    |
  397.     9:  HStr := "September "    |
  398.     10: HStr := "Oktober "    |
  399.     11: HStr := "November "    |
  400.     12: HStr := "Dezember "    |
  401.   END;
  402.   Concat( DatString, HStr);
  403.   ValToStr( Jahr, FALSE, HStr, 10, 4, "0", Error);
  404.   Concat( DatString, HStr); Concat( DatString, "  ");
  405.   ValToStr( Datum.minute DIV 60, FALSE, HStr, 10, 2, "0", Error);
  406.   Concat( DatString, HStr); Concat( DatString, ".");
  407.   ValToStr( Datum.minute REM 60, FALSE, HStr, 10, 2, "0", Error);
  408.   Concat( DatString, HStr); Concat( DatString, " Uhr");
  409. END ConvertDate;
  410.  
  411.  
  412. (*****************************************************************************)
  413. (***************** Hauptprogramm als endlicher Automat ***********************)
  414. (*****************************************************************************)
  415.  
  416. BEGIN (* M2P *)
  417.   waitCloseGadget := FALSE;    (* Damit Fenster am Ende von allein schließt *)
  418.   WriteString(" Modula-2 Quelltext-Lister");WriteLn;
  419.   WriteString("---------------------------");WriteLn;
  420.   WriteLn;
  421.   IF NumArgs()>=1 THEN
  422.     GetArg(1,InputName,Len);
  423.     WriteString("Die Datei ");
  424.     WriteString(InputName);
  425.     WriteString(" wird gedruckt...");
  426.     WriteLn; WriteLn;
  427.   ELSE
  428.     WriteString("Zu druckendes Listing: ");
  429.     WriteLn;WriteLn;
  430.     WriteString("in>");
  431.     ReadLn(InputName, Len);
  432.   END;
  433.   Lookup(InFile,InputName,512,FALSE); (* Eingabedatei öffnen *)
  434.   IF InFile.res#done THEN
  435.     WriteString("Quelldatei konnte nicht geöffnet werden!");
  436.     WriteLn;
  437.     HALT
  438.   END;
  439.   IF NOT wbStarted THEN
  440.     WriteString("Ausgabedatei: (prt: für Ausgabe auf Drucker)");
  441.     WriteLn;WriteLn;
  442.     WriteString("out>");
  443.     ReadLn(OutputName, Len);
  444.   ELSE
  445.     OutputName := "prt:"
  446.   END;
  447.   Lookup(OutFile,OutputName,0,TRUE); (* Ausgabedatei öffnen *)
  448.   IF OutFile.res # done THEN
  449.     WriteString("Ausgabedatei konnte nicht geöffnet werden!");
  450.     WriteLn;
  451.     Close(InFile);
  452.     HALT
  453.   END;
  454.   ReadPrefs;
  455.   InitDrucker;
  456.   ZeilenNr    := 0;
  457.   SeitenNr    := 0;
  458.   Zustand    := ZeichenLesen;
  459.   Zeichen    := eol;
  460.   CharCount    := 0;
  461.   ConvertDate;
  462.   WHILE (Zustand # FileEnde) AND (OutFile.res = done) DO
  463.     CASE Zustand OF
  464.     |ZeichenLesen:
  465.       CASE Zeichen OF
  466.       |"A".."Z":
  467.     INC(CharCount);
  468.         ZeichenZahl:=0;
  469.         Puffer[ZeichenZahl]:=Zeichen;
  470.         Zustand:=WortLesen;
  471.       |'"':
  472.     INC(CharCount);
  473.         Write(Zeichen);
  474.         Zustand:=String1;
  475.       |"'":
  476.     INC(CharCount);
  477.         Write(Zeichen);
  478.         Zustand:=String2;
  479.       |"(":
  480.         Read(Zeichen);
  481.         IF Zeichen = '*' THEN
  482.       INC(CharCount,2);
  483.           KursivAn;
  484.           Write("("); Write("*");
  485.           KommentarTiefe:=1;
  486.           Zustand:=Kommentar;
  487.         ELSE
  488.       INC(CharCount);
  489.           Write("(");
  490.           PushBack(Zeichen);
  491.         END;
  492.       |eol,cr:
  493.     CharCount := 0;
  494.         NeueZeile;
  495.       |ht:
  496.         FOR count := 1 TO 8 - (CharCount MOD 8) DO Write(" ") END;
  497.     CharCount := CharCount + (8 - (CharCount MOD 8));
  498.       |ff:
  499.     NeueSeite;
  500.       |nul..bs,vt,so..us:
  501.     WriteCtrl(Zeichen);
  502.       ELSE
  503.     INC(CharCount);
  504.         Write(Zeichen);
  505.       END;
  506.     |WortLesen:
  507.       IF (Zeichen >= "A") AND (Zeichen <= "Z") THEN
  508.         IF ZeichenZahl < ZeichenProZeile THEN
  509.           INC(ZeichenZahl);
  510.           Puffer[ZeichenZahl]:=Zeichen;
  511.       INC(CharCount);
  512.         END;
  513.       ELSE
  514.         IF ZeichenZahl < ZeichenProZeile THEN
  515.           INC(ZeichenZahl);
  516.           Puffer[ZeichenZahl]:=0C;
  517.         END;
  518.         IF ReserviertesWort(Puffer) THEN
  519.           MarkiereWort(Puffer,ZeichenZahl);
  520.         ELSE
  521.           WriteBytes(OutFile,ADR(Puffer),ZeichenZahl,Dummy);
  522.         END;
  523.         PushBack(Zeichen);
  524.         Zustand:=ZeichenLesen;
  525.       END;
  526.     |String1:
  527.       CASE Zeichen OF
  528.       |nul..us:
  529.     WriteCtrl(Zeichen);
  530.       ELSE
  531.     INC(CharCount);
  532.     Write(Zeichen);
  533.     IF Zeichen = '"' THEN
  534.       Zustand := ZeichenLesen;
  535.     END;
  536.       END;
  537.     |String2:
  538.       CASE Zeichen OF
  539.       |nul..us:
  540.     WriteCtrl(Zeichen);
  541.       ELSE
  542.     INC(CharCount);
  543.     Write(Zeichen);
  544.     IF Zeichen = "'" THEN
  545.       Zustand := ZeichenLesen;
  546.     END;
  547.       END;
  548.     |Kommentar:
  549.       CASE Zeichen OF
  550.       |'(':
  551.         Read(Zeichen);
  552.         IF Zeichen="*" THEN
  553.       INC(CharCount,2);
  554.           Write("("); Write("*");
  555.           INC(KommentarTiefe);
  556.         ELSE
  557.       INC(CharCount);
  558.           Write("(");
  559.           PushBack(Zeichen);
  560.         END;
  561.       |'*':
  562.         Read(Zeichen);
  563.         IF Zeichen=")" THEN
  564.       INC(CharCount,2);
  565.           Write("*"); Write(")");
  566.           DEC(KommentarTiefe);
  567.           IF KommentarTiefe=0 THEN
  568.             KursivAus;
  569.             Zustand:=ZeichenLesen;
  570.           END;
  571.         ELSE
  572.       INC(CharCount);
  573.           Write("*");
  574.           PushBack(Zeichen);
  575.         END;
  576.       |eol:
  577.     CharCount := 0;
  578.         NeueZeile
  579.       |ht:
  580.         FOR count := 1 TO 8 - (CharCount MOD 8) DO Write(" ") END;
  581.     CharCount := CharCount + (8 - (CharCount MOD 8));
  582.       |nul..bs,vt..us:
  583.     WriteCtrl(Zeichen);
  584.       ELSE
  585.     INC(CharCount);
  586.         Write(Zeichen);
  587.       END; (* CASE Zeichen *)
  588.     END; (* CASE Zustand *)
  589.     Read(Zeichen);
  590.   END; (* WHILE *)
  591.   Write(ff);
  592.   Close(InFile);
  593.   Close(OutFile);
  594. END M2P.
  595.